import api from '@/utils/api.js'

// API请求服务
const BASE_URL = 'http://localhost:9999';

// 登录状态标记，避免重复登录请求
let isLoginRequest = false;

// 请求拦截器
const requestInterceptor = (config) => {
  // 获取token
  const token = uni.getStorageSync('loginUserInfo').token || '';
  // console.log("添加请求头token:", token)
  if (token) {
    // 添加token到请求头
    config.header = {
      ...config.header,
      'Authorization': `${token}`
    };
  }
  return config;
};

// 响应拦截器
const responseInterceptor = async (response, options) => {
  // console.log('响应拦截器response:', response)
  const {
    code,
    data,
    success,
    message
  } = response.data

  // console.log(code)

  // 获取用户信息 - wx.getUserProfile() - 用户信息为加密返回，使用aes加sessionkey进行解密（服务端）
  if (code == -1) {
    // 让用户授权，服务端保存用户信息 - 手机号，昵称，头像
    // 缓存设置时间，过期后让用户重新授权，更新用户信息
  }

  // 用户身份失效 重新获取token 无感 - wx.login()
  if (code == 401) {
    // 避免重复登录请求
    if (isLoginRequest) {
      return Promise.reject(response);
    }

    try {
      isLoginRequest = true;

      const {
        code: loginCode
      } = await wx.login();
      console.log('获取登录码:', loginCode);
      const res = await api.user.miniAppLogin(loginCode);
      uni.setStorageSync("loginUserInfo", res);

      // 重置登录状态
      isLoginRequest = false;

      // 如果是重试请求，则不再次重试
      if (options && options.isRetry) {
        return Promise.reject(response);
      }

      // 重新发起之前失败的请求
      console.log('重新发起请求:', options);
      return request({
        ...options,
        isRetry: true
      });
    } catch (error) {
      isLoginRequest = false;
      return Promise.reject(error);
    }
  }

  // 如果返回的状态码为200，说明接口请求成功，可以正常拿到数据
  if (code === 200) {
    // console.log("响应体:", data)
    // 判断业务状态码
    if (success) {
      return data;
    } else {
      // 业务错误处理
      uni.showToast({
        title: message || '网络错误',
        icon: 'none'
      });
      return Promise.reject(data);
    }
  } else {
    // HTTP错误处理
    uni.showToast({
      title: `服务器繁忙，请重试`,
      icon: 'none'
    });
    return Promise.reject(response);
  }
};

// 封装请求方法
const request = (options) => {
  // 应用请求拦截器
  const interceptedOptions = requestInterceptor(options);

  return new Promise((resolve, reject) => {
    uni.request({
      url: `${BASE_URL}${interceptedOptions.url}`,
      method: interceptedOptions.method || 'GET',
      data: interceptedOptions.data,
      header: interceptedOptions.header || {},
      success: (res) => {
        // 应用响应拦截器，传入原始请求配置用于重试
        responseInterceptor(res, options)
          .then(result => {
            resolve(result);
          })
          .catch(error => {
            reject(error);
          });
      },
      fail: (err) => {
        console.error('网络请求失败:', err);
        uni.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
        reject(err);
      }
    });
  });
};

// 封装GET请求
const get = (url, params = {}, options = {}) => {
  return request({
    url,
    method: 'GET',
    data: params,
    ...options
  });
};

// 封装POST请求
const post = (url, data = {}, options = {}) => {
  return request({
    url,
    method: 'POST',
    data,
    ...options
  });
};

// 封装delete请求
const del = (url, data = {}, options = {}) => {
  return request({
    url,
    method: 'DELETE',
    data,
    ...options
  });
};

// 导出
export default {
  request,
  get,
  post,
  del
};